home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / Venus / SimpleWindow.cc < prev    next >
Text File  |  1996-06-22  |  14KB  |  438 lines
  1. /*
  2.  ***********************************************************************
  3.  *
  4.  *                    Simple Window Class
  5.  *    A generic simple window that can be dragged around the screen
  6.  *        and closed by clicking a "go-away" button
  7.  * No other events are handled, redefine the event handler if necessary.
  8.  *        
  9.  *
  10.  ***********************************************************************
  11.  */
  12.  
  13. #include "image.h"
  14. #include "mymenv.h"
  15. #include "window.h"
  16. //#include <PictUtil.h>
  17.  
  18. /*
  19.  *----------------------------------------------------------------------
  20.  *                Service functions
  21.  */
  22.  
  23.                 // Getting a bounding rectangle of an image
  24. ScreenRect::ScreenRect(const IMAGE& image)
  25. {
  26.   left = top = 0;
  27.   right = image.q_ncols();
  28.   bottom = image.q_nrows();
  29. }
  30.  
  31. #if 0
  32.  
  33.                 // Create a rectangle of given height/width
  34.                 // positioned at the origin
  35. ScreenRect::ScreenRect(const rowcol& heightwidth)
  36. {
  37.   left = top = 0;
  38.   bottom = heightwidth.row();
  39.   right  = heightwidth.col();
  40. }
  41.  
  42.                     // Create a rectangle of given height/width
  43.                     // positioned at a given point
  44. ScreenRect::ScreenRect(const rowcol& origin, const rowcol& heightwidth)
  45. {
  46.   top  = origin.row();
  47.   left = origin.col();
  48.   bottom = top+heightwidth.row();
  49.   right  = left+heightwidth.col();
  50. }
  51. #endif
  52.  
  53.  
  54.                     // Shifting a rectangle by the same amount
  55.                     // in X and Y
  56. ScreenRect& ScreenRect::operator += (const int offset)
  57. { 
  58.   top += offset; bottom += offset; left += offset; right += offset;
  59.   return *this;
  60. }
  61.  
  62.  
  63.                     // Print what rectangle is this
  64. void ScreenRect::print(const char * title) const
  65. {
  66.   alert("Rectangle %s (%d,%d) - (%d,%d)",title,top,left,bottom,right);
  67. }
  68.  
  69.  
  70. #if 0
  71. /*
  72.  *----------------------------------------------------------------------
  73.  *                 Primitive Window creators/destructors
  74.  */
  75.  
  76.                         // This is a protected constructor. Normally
  77.                         // objects XVTBasicWindow are created as a part
  78.                         // of a derived class
  79. XVTBasicWindow::XVTBasicWindow(void)
  80. {
  81.   Not_canceled = FALSE;
  82.   this_window = NULL_WIN;
  83. }
  84.  
  85.                         // Destroy the window if it hasn't been destroyed
  86.                         // already
  87. XVTBasicWindow::~XVTBasicWindow(void)
  88. {
  89.   if( this_window != 0 )
  90.     close_window(this_window);
  91. }
  92.  
  93.                         // Close the window
  94. void XVTBasicWindow::cancel(void)
  95. {
  96.   Not_canceled = FALSE;
  97.   if( this_window != 0 )
  98.     close_window(this_window);
  99. }
  100.  
  101. /*
  102.  *----------------------------------------------------------------------
  103.  *                   Basic event dispatching/handling
  104.  */
  105.  
  106.                         // A universal event handler: does almost nothing
  107.                         // but watches creation and destruction of windows
  108.                         // (to tell when there are no windows to watch)
  109.                         // For any other tasks, it calls the handler of
  110.                         // a particular window
  111. int XVTBasicWindow::no_opened_windows = 0;
  112. long XVTBasicWindow::universal_handler(WINDOW win, EVENT *ep)
  113.  
  114. {
  115.   XVTBasicWindow& the_window = *(XVTBasicWindow *)get_app_data(win);
  116.  
  117.   if( ep->type == E_CREATE )
  118.     no_opened_windows++, the_window.this_window = win;
  119.  
  120.   the_window.handler(*ep);
  121.  
  122.                                 // XVT would destroy the window after this
  123.                                 // event
  124.   if( ep->type == E_DESTROY )
  125.     no_opened_windows--, the_window.this_window = 0;
  126.  
  127.   return 0;
  128. }
  129.  
  130.                                 // Serve the windows until all get closed
  131. void XVTBasicWindow::serve_to_death(void)
  132. {
  133.   while( no_opened_windows>0 )
  134.     process_events();
  135. }
  136.  
  137.  
  138.                         // Event handler for a particular window
  139.                         // Finally, a handler which really does smth
  140.                         // specific
  141. void XVTBasicWindow::handler(EVENT event)
  142. {
  143.   switch(event.type)
  144.   {
  145.     case E_CREATE:
  146.          if( !initialize() )
  147.            cancel();
  148.          break;
  149.   }
  150. }
  151.  
  152. /*
  153.  *----------------------------------------------------------------------
  154.  *                              Window creators
  155.  *
  156.  * Note, event processing may start *before* the create_* functions return!
  157.  * So, if initialize() or event handlers, etc rely on some data that are
  158.  * going to be initialized *after* create_* function, you're in trouble!
  159.  * It's better to call create() function the last thing in the constructor,
  160.  * or even not to call at all (call it separetely later) to allow derived
  161.  * classes initialize properly!
  162.  *
  163.  */
  164. #endif
  165.  
  166. /*
  167.  *----------------------------------------------------------------------
  168.  *                              Window creators
  169.  */
  170.  
  171.                 // Create a color window of the specified size and title
  172.                 // Note, the upper left corner of 'rect' must
  173.                 // NOT be (0,0)!
  174. ScreenWindow::ScreenWindow(ScreenRect rect, const char * title)
  175. {
  176.   const int window_offset = 100;        // Cannot be 0 or small!
  177.   this_window = NewCWindow(nil,rect += window_offset,(Pstr)title,
  178.                TRUE,noGrowDocProc,
  179.                (WindowPtr)(-1),TRUE,(long)this);
  180.   assert( this_window != 0 );
  181.   SetPort(this_window);
  182.   SelectWindow(this_window);
  183. }
  184.  
  185.                 // Create a color window from a resource template
  186. ScreenWindow::ScreenWindow(const short resource_id)
  187. {
  188.   this_window = GetNewCWindow(resource_id,nil,(WindowPtr)(-1));
  189.   SetWRefCon(this_window,(long)this);
  190.   assert( this_window != 0 );
  191.   SetPort(this_window);
  192.   SelectWindow(this_window);
  193. }
  194.  
  195.  
  196.             // I wouldn't've needed this is destructor had been really virtual. Right now,
  197.             // CW 6.0 accepts attribute virtual for the destructor, but doesn't override
  198.             // destructors as it does for virtual functions. Oh, well, another kludge
  199.  
  200.                             // Close the window and clean up the rubble
  201. void ScreenWindow::destroy_it(void)
  202. {
  203.   assert( this_window != 0 );
  204.   DisposeWindow(this_window);
  205.   this_window = 0;
  206. }
  207.  
  208. /*
  209.  *----------------------------------------------------------------------
  210.  *                           Basic Even Handling
  211.  */
  212.  
  213.                 // Top-level event dispatcher
  214.                 // Returns FALSE when the window is to be destroyed
  215.                 // and won't need any further events
  216. Boolean ScreenWindow::handle_event(const EventRecord& the_event)
  217. {
  218.   switch( the_event.what )
  219.   {
  220.     case mouseDown:
  221.          WindowPtr    wp;
  222.          short        windowPart = FindWindow(the_event.where, &wp);
  223.          if( !handle_mouse_down(the_event,wp,windowPart) )
  224.            return FALSE;        // Window is to be closed (go-away buttin clicked)
  225.          break;
  226.             
  227.     case updateEvt:
  228.          if( this_window == (WindowPtr)the_event.message )
  229.            update();
  230.          break;
  231.  
  232.     case keyDown:
  233.     case autoKey:
  234.          if( !handle_key_down(the_event) )
  235.            return FALSE;        // a "quit" key must've been pressed
  236.          break;
  237.                         
  238.     case activateEvt:
  239.          if( this_window == (WindowPtr)the_event.message )
  240.            if( the_event.modifiers & 0x01 )
  241.              SetPort(this_window);
  242.   }
  243.   return TRUE;
  244. }
  245.  
  246.                 // Handle "mouse-down" events
  247.                 // Returns FALSE if the user clicked within the
  248.                 // go-away region of our window. Otherwise,
  249.                 // returns TRUE
  250.                 // Handles dragging if necessary and system clicks
  251. Boolean ScreenWindow::handle_mouse_down
  252.     (const EventRecord& the_event, WindowPtr where_window, short window_part)
  253. {
  254.   switch( window_part )
  255.   {
  256.     case inSysWindow: 
  257.          SystemClick(&the_event, where_window);
  258.      break;
  259.         
  260.     case inMenuBar:
  261.          break;                // Don't handle it yet
  262.  
  263.     case inContent:
  264.          break;
  265.           
  266.     case inDrag:
  267.          if( this_window == where_window )
  268.            DragWindow(this_window,the_event.where,&qd.screenBits.bounds);
  269.          break;
  270.                       
  271.     case inGoAway:
  272.          return !TrackGoAway(where_window, the_event.where);
  273.   }
  274.   return TRUE;
  275. }
  276.  
  277.                 // Handles key_down & auto_key events. Return FALSE
  278.                 // if the window is to be closed down
  279. Boolean ScreenWindow::handle_key_down(const EventRecord& the_event)
  280. {
  281.   return FALSE;                // Any key kills the application, sorry
  282. }
  283.  
  284.  
  285.                 // Handles null events, when nothing happens for some
  286.                 // time. Return FALSE when it's time to die
  287. Boolean ScreenWindow::handle_null_event(const long event_time)
  288. {
  289.   return TRUE;                            // Keep going
  290. }
  291.  
  292.  
  293.  
  294.             // Private window parts
  295.                 // Handle an update event - redraw the window
  296.                 // A virtual function draw() is called to do
  297.                 // the actual redrawing
  298. void ScreenWindow::update(void)
  299. {
  300.   SetNewGrafPtr((GrafPtr)this_window);
  301.   BeginUpdate(this_window);
  302.   draw();
  303.   EndUpdate(this_window);
  304. }
  305.  
  306.                 // Make the entire window being redrawn
  307. void ScreenWindow::refresh(void)
  308. {
  309.   InvalRect(&this_window->portRect);            
  310. }
  311.  
  312.  
  313. /*
  314.  *----------------------------------------------------------------------
  315.  *                An off-screen pixel buffer for faster drawing
  316.  */
  317.  
  318.                     // Allocate the buffer for offscreen
  319.                     // drawing and load a CLUT (if clut_id != 0)
  320. OffScreenBuffer::OffScreenBuffer(ScreenRect rect, const short clut_id)
  321.     : graf_world(nil)
  322. {
  323.   CTabHandle clut_handle = nil;
  324.   if( clut_id != 0 )
  325.   {                                        // try to get a user CLUT with that resource id
  326.     clut_handle = GetCTable(clut_id);
  327.     assert( clut_handle != 0 );
  328.   }
  329.   do_well( NewGWorld(&graf_world,8,rect,clut_handle,nil,0) );
  330.   assert( graf_world != nil );
  331.  
  332.   if( clut_handle != nil )
  333.     DisposCTable(clut_handle);        // CLUT has been copied, and can be disposed of now
  334.  
  335.                     // Get hold of the offscreen pixmap
  336.   pixmap = GetGWorldPixMap(graf_world);            // and make sure it looks like
  337.   assert( pixmap != nil && *pixmap != nil );    // we can use it
  338.  
  339.   assert( (**pixmap).cmpCount == 1 );            // We have a color table index
  340.   assert( !PixMap32Bit(pixmap) );
  341.  
  342.   _height = abs((**pixmap).bounds.top - (**pixmap).bounds.bottom);
  343.   _width  = abs((**pixmap).bounds.right - (**pixmap).bounds.left);
  344.   _bytes_per_row = (**pixmap).rowBytes & 0x7fff;
  345.  
  346.   assert( _height > 0 && _height < 10000 );         // Just to play safe
  347.   assert( _width > 0 && _width <= _bytes_per_row );    
  348. }
  349.  
  350.                     // Dispose of the offscreen buffer
  351. OffScreenBuffer::~OffScreenBuffer(void)
  352. {
  353.   assert( graf_world != nil );
  354.   DisposeGWorld(graf_world);
  355.   graf_world = nil;
  356. #if 0
  357.   PaletteHandle window_palette = GetPalette(our_window());
  358.   if( window_palette != nil )        // dispose of our palette if was allocated
  359.   {
  360.     SetPalette(our_window(),nil,FALSE);
  361.     DisposePalette(window_palette);
  362.   }
  363. #endif
  364.   pixmap = nil;
  365.   _height = _width = _bytes_per_row = 0;
  366. }
  367.  
  368. #if 0
  369.             // Make sure that the colors of our off-screen
  370.             // buffer would be displayed properly (or close enough)
  371.             // on screen
  372. void OffScreenBuffer::activate_palette(void)
  373. {
  374.   CTabHandle window_ctab = (**pixmap).pmTable;
  375.   assert( window_ctab != nil && *window_ctab != nil );
  376.  
  377.   PaletteHandle palette = NewPalette((**window_ctab).ctSize,window_ctab,pmTolerant+pmExplicit,0);
  378.   assert( palette != nil );
  379.   SetPalette(our_window(),palette,TRUE);
  380.   do_well( QDError() );
  381.   ActivatePalette(our_window());    
  382.   do_well( QDError() );
  383. }
  384. #endif
  385.  
  386.  
  387.                 // Actual drawing - moving the picture from the
  388.                 // offscreen grafworld to the onscreen one, to the current port.
  389.                 // Remember to set a device to that of the offscreen
  390.                 // grafworld before CopyBits (in order to get grafworld's color table and 
  391.                 // inverse color table to be used): see IM, Palette Manager
  392.                 // Also note, if a window we're going to draw on is partly/completely
  393.                 // obscured, then the visRgn, the visible region of the on-screen window,
  394.                 // is *not* a window rectangle. When we make the offscreen grafworld the
  395.                 // current grafport for CopyBits, CopyBits has no way of knowing then that
  396.                 // the true destination region may not be the whole where_rect at all. To make
  397.                 // CopyBits aware of the fact that the onscreen window maybe abscured, we
  398.                 // pass the visRgn of the onscreen window as a clipping region to CopyBits.
  399.                 // In that case CopyBits performs clipping just as if the onscreen window
  400.                 // where the current grafport.
  401.                 // Note, to be really precise, we ought to pass CopyBits() an intersection of
  402.                 // onscreen grafport's visRgn and clipRgn. Well, we take a shortcut here:
  403.                 // normally clipRgn is set to be the whole screen. Moreover, visRgn is clipped
  404.                 // already not only to the unobscured part of the window, but to the update
  405.                 // region as well. So using visRgn only should suffice....
  406.                 // Also make sure that the onscreen window has a palette roughly corresponding
  407.                 // to the CLUT of the grafworld (otherwise colors would be screwed up)
  408.                 // One can use a palette resource 0 to be used as a default palette for
  409.                 // dialogs/windows within the task
  410.                 
  411.                 // Note there is a different way to force color translation when drawing a picture
  412.                 // (seems to work better in 68k universe). One needs to create a grafworld, and
  413.                 // and draw on it within OpenPicture()...ClosePicture(). Then one can draw
  414.                 // thus recorded picture on the current window. The colors seem to get translated
  415.                 // correctly, and one doesn't need to worry about clipping, etc (as in the method
  416.                 // way explained above). One can use this technique to force 24->8 color
  417.                 // translation (with dithering) if the grafworld was created as 24-bit.
  418.  
  419. void OffScreenBuffer::draw(const Rect& where_rect, const Rect& from_rect)
  420. {
  421. //  const BitMap * where_pixmap = &qd.thePort->portBits;    // see below
  422.   CGrafPtr old_port;
  423.   GDHandle old_gdevice;
  424.   GetGWorld(&old_port,&old_gdevice);
  425.   const RgnHandle where_visible_region = old_port->visRgn;
  426.   SetGWorld((CGrafPtr)graf_world,nil);
  427.                                                   // The following line is actually the same as
  428.                                                   // the one commented at the very top. However,
  429.                                                   // thePort stuff doesn't work under OpenDoc, but
  430.                                                   // the following line does.
  431.   const BitMap * where_pixmap = &((GrafPtr)old_port)->portBits;
  432.   //!!!Set_NewGrafWorld((GWorldPtr)graf_world);    // Doesn't work: CW disposes of the object too early
  433.   assert( LockPixels(pixmap) );
  434.   CopyBits((const BitMap *)*pixmap, where_pixmap, &from_rect, &where_rect, /*ditherCopy*/ srcCopy, where_visible_region);
  435.   SetGWorld(old_port,old_gdevice);
  436.   UnlockPixels(pixmap);
  437. }
  438.